home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 22 / CU Amiga Magazine's Super CD-ROM 22 (1998)(EMAP Images)(GB)[!][issue 1998-05].iso / PowerPC / Programming / PPCSmallEiffel / bin_c / compile_to_c26.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  36.0 KB  |  1,327 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_c.h"
  9. T0* r940add_comment(T940* C,T0* a1){
  10. T0* R=NULL;
  11. /*IF*/if (((a1)==((void*)(NULL)))||((/*(IRF4.6count*/r52count(((T52*)((((T393*)((T393*)a1)))->_list/*4*/)))/*)*/)==(0))) {
  12. R=(T0*)C;
  13. }
  14. else {
  15. {T529*n=malloc(sizeof(*n));
  16. *n=M529;
  17. r529make(n,(T0*)C,a1);
  18. R=(T0*)n;
  19. }
  20. }
  21. /*FI*/return R;
  22. }
  23. int r940to_integer(T940* C){
  24. int R=0;
  25. r940error((((T940*)C))->_start_position/*12*/,((T0*)ms69_470));
  26. return R;
  27. }
  28. int r940is_a(T940* C,T0* a1){
  29. int R=0;
  30. R=X609is_a(/*(IRF4.4run_type*/((T0*)((T549*)(((T940*)C))->_result_type/*20*/))/*)*/,X291run_type(X662result_type(a1)));
  31. /*IF*/if (!(R)) {
  32. r683add_position((((T940*)C))->_start_position/*12*/);
  33. r940error(X662start_position(a1),((T0*)ms4_662));
  34. }
  35. /*FI*/return R;
  36. }
  37. /*No:BIT_CONSTANT.is_current*/
  38. /*No:BIT_CONSTANT.mapping_c_arg*/
  39. /*No:BIT_CONSTANT.static_value*/
  40. void r940make(T940* C,T0* a1,T0* a2){
  41. C->_start_position=a1;
  42. C->_value=a2;
  43. }
  44. /*No:BIT_CONSTANT.mapping_c_target*/
  45. /*No:BIT_CONSTANT.fz_iinaiv*/
  46. /*No:BIT_CONSTANT.dca_inline_argument*/
  47. /*No:BIT_CONSTANT.start_position*/
  48. void r940compile_to_c(T940* C){
  49. int _ib=0;
  50. int _nb=0;
  51. T0* _tb=NULL;
  52. _tb=(((T940*)C))->_result_type/*20*/;
  53. _ib= (CHAR_BIT*sizeof(int)) ;
  54. /*IF*/if (X609is_c_unsigned_ptr(_tb)) {
  55. r940compute_c_to_bit(C);
  56. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  57. char b1='\50';
  58. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  59. }/*]*/
  60. /*]*/
  61. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  62. char b1='\50';
  63. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  64. }/*]*/
  65. /*]*/
  66. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms132_470));
  67. /*]*/
  68. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  69. char b1='\52';
  70. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  71. }/*]*/
  72. /*]*/
  73. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  74. char b1='\51';
  75. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  76. }/*]*/
  77. /*]*/
  78. r324put_string_c(oBC940to_bit);
  79. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  80. char b1='\51';
  81. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  82. }/*]*/
  83. /*]*/
  84. }
  85. else {
  86. r7copy(((T7*)(oBC940to_bit)),(((T940*)C))->_value/*16*/);
  87. /*IF*/if (X609is_c_char(_tb)) {
  88. _nb= CHAR_BIT ;
  89. }
  90. else {
  91. _nb= (CHAR_BIT*sizeof(int)) ;
  92. }
  93. /*FI*/while (!(((((T7*)((T7*)(oBC940to_bit))))->_count/*4*/)==(_nb))) {
  94. r7extend(((T7*)(oBC940to_bit)),'0');
  95. }
  96. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),r7binary_to_integer(((T7*)(oBC940to_bit))));
  97. /*]*/
  98. }
  99. /*FI*/}
  100. /*No:BIT_CONSTANT.c_simple*/
  101. T0* r940to_runnable(T940* C,T0* a1){
  102. T0* R=NULL;
  103. T0* _ic=NULL;
  104. /*IF*/if (((((T940*)C))->_current_type/*8*/)==((void*)(NULL))) {
  105. C->_current_type=a1;
  106. /*IF*/if (((((T940*)C))->_result_type/*20*/)==((void*)(NULL))) {
  107. {T342*n=malloc(sizeof(*n));
  108. *n=M342;
  109. r342make(n,(((T7*)((T7*)((((T940*)C))->_value/*16*/))))->_count/*4*/,(((T940*)C))->_start_position/*12*/);
  110. _ic=(T0*)n;
  111. }
  112. {T549*n=malloc(sizeof(*n));
  113. *n=M549;
  114. r549make(n,(((T940*)C))->_start_position/*12*/,_ic);
  115. C->_result_type=(T0*)n;
  116. }
  117. r355set_at_run_time(((T355*)(r549run_class(((T549*)((((T940*)C))->_result_type/*20*/))))));
  118. }
  119. /*FI*/R=(T0*)C;
  120. }
  121. else {
  122. R=r940twin(C);
  123. /*[IRF3.3set_current_type*/((((T940*)(((T940*)R))))->_current_type)=(NULL);
  124. /*]*/
  125. R=r940to_runnable(((T940*)R),a1);
  126. }
  127. /*FI*/return R;
  128. }
  129. /*No:BIT_CONSTANT.result_type*/
  130. /*No:BIT_CONSTANT.is_result*/
  131. T0* r940twin(T940* C){
  132. T0* R=NULL;
  133. R=malloc(sizeof(*C));
  134. *((T940*)R)=*C;
  135. return R;
  136. }
  137. /*No:BIT_CONSTANT.set_current_type*/
  138. /*No:BIT_CONSTANT.is_static*/
  139. /*No:BIT_CONSTANT.value*/
  140. T0*oBC940to_bit=NULL;
  141. /*No:BIT_CONSTANT.fz_unsigned*/
  142. /*No:BIT_CONSTANT.can_be_dropped*/
  143. /*No:BIT_CONSTANT.current_type*/
  144. /*No:BIT_CONSTANT.compile_to_c_old*/
  145. /*No:BIT_CONSTANT.static_value_mem*/
  146. /*No:BIT_CONSTANT.is_manifest_string*/
  147. /*No:BIT_CONSTANT.is_void*/
  148. void r940compute_c_to_bit(T940* C){
  149. int _i_value=0;
  150. int _i_to_bit=0;
  151. T0* _char_bit=NULL;
  152. _i_to_bit=((((T7*)((T7*)((((T940*)C))->_value/*16*/))))->_count/*4*/)/( (CHAR_BIT*sizeof(int)) );
  153. /*IF*/if ((((((T7*)((T7*)((((T940*)C))->_value/*16*/))))->_count/*4*/)%( (CHAR_BIT*sizeof(int)) ))!=(0)) {
  154. _i_to_bit=(_i_to_bit)+(1);
  155. }
  156. /*FI*/_i_to_bit=(_i_to_bit)*(( (CHAR_BIT*sizeof(int)) )/( CHAR_BIT ));
  157. /*[IRF3.3clear*/((((T7*)(((T7*)(oBC940to_bit)))))->_count)=(0);
  158. /*]*/
  159. _char_bit=((T0*)ms1_940);
  160. _i_value=1;
  161. while (!((_i_to_bit)==(0))) {
  162. /*[IRF3.3clear*/((((T7*)(((T7*)_char_bit))))->_count)=(0);
  163. /*]*/
  164. while (!(((((T7*)((T7*)_char_bit)))->_count/*4*/)==( CHAR_BIT ))) {
  165. /*IF*/if ((_i_value)<=((((T7*)((T7*)((((T940*)C))->_value/*16*/))))->_count/*4*/)) {
  166. r7extend(((T7*)_char_bit),/*(IRF4.6item*/((((T7*)((T7*)((((T940*)C))->_value/*16*/))))->_storage/*0*/)[(_i_value)-(1)]/*)*/);
  167. }
  168. else {
  169. r7extend(((T7*)_char_bit),'0');
  170. }
  171. /*FI*/_i_value=(_i_value)+(1);
  172. }
  173. r7extend(((T7*)(oBC940to_bit)),((char)(r7binary_to_integer(((T7*)_char_bit)))));
  174. _i_to_bit=(_i_to_bit)-(1);
  175. }
  176. }
  177. /*No:BIT_CONSTANT.is_pre_computable*/
  178. /*No:BIT_CONSTANT.use_current*/
  179. void r940error(T0* a1,T0* a2){
  180. r683add_position(a1);
  181. r683error(((T683*)(oBC364eh)),a2);
  182. }
  183. /*No:BIT_CONSTANT.isa_dca_inline_argument*/
  184. /*No:BIT_CONSTANT.afd_check*/
  185. T0* r367add_comment(T367* C,T0* a1){
  186. T0* R=NULL;
  187. /*IF*/if (((a1)==((void*)(NULL)))||((/*(IRF4.6count*/r52count(((T52*)((((T393*)((T393*)a1)))->_list/*4*/)))/*)*/)==(0))) {
  188. R=(T0*)C;
  189. }
  190. else {
  191. {T529*n=malloc(sizeof(*n));
  192. *n=M529;
  193. r529make(n,(T0*)C,a1);
  194. R=(T0*)n;
  195. }
  196. }
  197. /*FI*/return R;
  198. }
  199. /*No:E_FALSE.to_integer*/
  200. int r367is_a(T367* C,T0* a1){
  201. int R=0;
  202. R=X291is_a(/*(IRF4.4run_type*/((T0*)((T707*)/*(IRF4.8result_type*/r367type_boolean()/*)*/))/*)*/,X291run_type(X662result_type(a1)));
  203. /*IF*/if (!(R)) {
  204. r683add_position((((T367*)C))->_start_position/*12*/);
  205. r367error(X662start_position(a1),((T0*)ms4_662));
  206. }
  207. /*FI*/return R;
  208. }
  209. /*No:E_FALSE.is_current*/
  210. void r367mapping_c_arg(T0* a1){
  211. /*IF*/if (X291is_reference(a1)) {
  212. /*[IRF3.6to_reference*/{T707* C1=((T707*)(/*(IRF4.8result_type*/r367type_boolean()/*)*/));
  213. r324to_reference(((T324*)(oBC364cpp)),(T0*)C1,r707type_boolean_ref());
  214. }/*]*/
  215. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  216. char b1='\50';
  217. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  218. }/*]*/
  219. /*]*/
  220. /*[IRF3.2compile_to_c*//*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  221. char b1='0';
  222. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  223. }/*]*/
  224. /*]*/
  225. /*]*/
  226. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  227. char b1='\51';
  228. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  229. }/*]*/
  230. /*]*/
  231. }
  232. else {
  233. /*[IRF3.2compile_to_c*//*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  234. char b1='0';
  235. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  236. }/*]*/
  237. /*]*/
  238. /*]*/
  239. }
  240. /*FI*/}
  241. T0* r367type_boolean(void){
  242. if (fBC364type_boolean==0){
  243. T0* R=NULL;
  244. fBC364type_boolean=1;
  245. {T707*n=malloc(sizeof(*n));
  246. *n=M707;
  247. r707make(n,NULL);
  248. R=(T0*)n;
  249. }
  250. oBC364type_boolean=R;}
  251. return oBC364type_boolean;}
  252. /*No:E_FALSE.static_value*/
  253. /*No:E_FALSE.make*/
  254. /*No:E_FALSE.mapping_c_target*/
  255. /*No:E_FALSE.fz_iinaiv*/
  256. /*No:E_FALSE.dca_inline_argument*/
  257. /*No:E_FALSE.start_position*/
  258. /*No:E_FALSE.compile_to_c*/
  259. /*No:E_FALSE.c_simple*/
  260. T0* r367to_runnable(T367* C,T0* a1){
  261. T0* R=NULL;
  262. /*IF*/if (((((T367*)C))->_current_type/*8*/)==((void*)(NULL))) {
  263. C->_current_type=a1;
  264. R=(T0*)C;
  265. }
  266. else {
  267. R=r367twin(C);
  268. /*[IRF3.3set_current_type*/((((T367*)(((T367*)R))))->_current_type)=(a1);
  269. /*]*/
  270. }
  271. /*FI*/return R;
  272. }
  273. /*No:E_FALSE.result_type*/
  274. /*No:E_FALSE.is_result*/
  275. T0* r367twin(T367* C){
  276. T0* R=NULL;
  277. R=malloc(sizeof(*C));
  278. *((T367*)R)=*C;
  279. return R;
  280. }
  281. /*No:E_FALSE.set_current_type*/
  282. /*No:E_FALSE.is_static*/
  283. /*No:E_FALSE.can_be_dropped*/
  284. /*No:E_FALSE.current_type*/
  285. /*No:E_FALSE.compile_to_c_old*/
  286. /*No:E_FALSE.static_value_mem*/
  287. /*No:E_FALSE.is_manifest_string*/
  288. /*No:E_FALSE.is_void*/
  289. /*No:E_FALSE.is_pre_computable*/
  290. /*No:E_FALSE.use_current*/
  291. void r367error(T0* a1,T0* a2){
  292. r683add_position(a1);
  293. r683error(((T683*)(oBC364eh)),a2);
  294. }
  295. int r367isa_dca_inline_argument(void){
  296. int R=0;
  297. /*IF*/{/*AT*/R=-(1);
  298. }
  299. /*FI*/return R;
  300. }
  301. /*No:E_FALSE.afd_check*/
  302. void r671make(T671* C,T0* a1,T0* a2){
  303. C->_start_position=a1;
  304. C->_items=a2;
  305. }
  306. /*No:EXPORT_LIST.start_position*/
  307. T0* r671clients_for(T671* C,T0* a1){
  308. T0* R=NULL;
  309. T0* _ei=NULL;
  310. int _i=0;
  311. _i=1;
  312. while (!(((R)!=((void*)(NULL)))||((_i)>((((T587*)((T587*)((((T671*)C))->_items/*4*/))))->_upper/*8*/)))) {
  313. _ei=r587item(((T587*)((((T671*)C))->_items/*4*/)),_i);
  314. /*IF*/if (r542affect(((T542*)_ei),a1)) {
  315. R=(((T542*)((T542*)_ei)))->_clients/*0*/;
  316. }
  317. else {
  318. _i=(_i)+(1);
  319. }
  320. /*FI*/}
  321. return R;
  322. }
  323. /*No:EXPORT_LIST.items*/
  324. /*No:CLASS_NAME.us_none*/
  325. int r451is_subclass_of(T451* C,T0* a1){
  326. int R=0;
  327. /*IF*/if ((((T0*)ms1_473))==((void*)((((T451*)((T451*)a1)))->_to_string/*0*/))) {
  328. R=1;
  329. }
  330.  else if ((((T0*)ms19_473))==((void*)((((T451*)((T451*)a1)))->_to_string/*0*/))) {
  331. }
  332. else {
  333. R=r605is_subclass_of(((T605*)(r451base_class(C))),r451base_class(((T451*)a1)));
  334. }
  335. /*FI*/return R;
  336. }
  337. void r451make(T451* C,T0* a1,T0* a2){
  338. C->_start_position=a2;
  339. C->_to_string=r902item(a1);
  340. }
  341. /*No:CLASS_NAME.to_string*/
  342. void r451make_unknown(T451* C){
  343. {T627*n=malloc(sizeof(*n));
  344. *n=M627;
  345. r627with(n,1,1,(T0*)C);
  346. C->_start_position=(T0*)n;
  347. }
  348. C->_to_string=((T0*)ms3_451);
  349. }
  350. /*No:CLASS_NAME.start_position*/
  351. /*No:CLASS_NAME.unknown_name*/
  352. T0* r451base_class(T451* C){
  353. T0* R=NULL;
  354. R=r604base_class(((T604*)(oBC364small_eiffel)),(T0*)C);
  355. return R;
  356. }
  357. void r451identify(T451* C,T0* a1){
  358. C->_to_string=r902item(a1);
  359. }
  360. /*No:CLASS_NAME.us_any*/
  361. T0* r260add_comment(T260* C,T0* a1){
  362. T0* R=NULL;
  363. /*IF*/if (((a1)==((void*)(NULL)))||((/*(IRF4.6count*/r52count(((T52*)((((T393*)((T393*)a1)))->_list/*4*/)))/*)*/)==(0))) {
  364. R=(T0*)C;
  365. }
  366. else {
  367. {T529*n=malloc(sizeof(*n));
  368. *n=M529;
  369. r529make(n,(T0*)C,a1);
  370. R=(T0*)n;
  371. }
  372. }
  373. /*FI*/return R;
  374. }
  375. /*No:CHARACTER_CONSTANT.to_integer*/
  376. int r260is_a(T260* C,T0* a1){
  377. int R=0;
  378. R=X291is_a(/*(IRF4.4run_type*/((T0*)((T252*)r260result_type()))/*)*/,X291run_type(X662result_type(a1)));
  379. /*IF*/if (!(R)) {
  380. r683add_position((((T260*)C))->_start_position/*12*/);
  381. r260error(X662start_position(a1),((T0*)ms4_662));
  382. }
  383. /*FI*/return R;
  384. }
  385. /*No:CHARACTER_CONSTANT.is_current*/
  386. void r260mapping_c_arg(T260* C,T0* a1){
  387. /*IF*/if (X291is_reference(a1)) {
  388. /*[IRF3.6to_reference*/{T252* C1=((T252*)(r260result_type()));
  389. r324to_reference(((T324*)(oBC364cpp)),(T0*)C1,r252type_character_ref());
  390. }/*]*/
  391. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  392. char b1='\50';
  393. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  394. }/*]*/
  395. /*]*/
  396. r260compile_to_c(C);
  397. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  398. char b1='\51';
  399. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  400. }/*]*/
  401. /*]*/
  402. }
  403. else {
  404. r260compile_to_c(C);
  405. }
  406. /*FI*/}
  407. /*No:CHARACTER_CONSTANT.static_value*/
  408. void r260make(T260* C,T0* a1,char a2,int a3){
  409. C->_start_position=a1;
  410. C->_value=a2;
  411. /*[IRF3.3set_pretty_print_mode*/((((T260*)(C)))->_pretty_print_mode)=(a3);
  412. /*]*/
  413. }
  414. /*No:CHARACTER_CONSTANT.mapping_c_target*/
  415. /*No:CHARACTER_CONSTANT.fz_iinaiv*/
  416. /*No:CHARACTER_CONSTANT.set_pretty_print_mode*/
  417. /*No:CHARACTER_CONSTANT.dca_inline_argument*/
  418. /*No:CHARACTER_CONSTANT.start_position*/
  419. void r260compile_to_c(T260* C){
  420. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  421. char b1='\47';
  422. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  423. }/*]*/
  424. /*]*/
  425. /*IF*/if ((r3is_letter((((T260*)C))->_value/*16*/))||(r3is_digit((((T260*)C))->_value/*16*/))) {
  426. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  427. char b1=(((T260*)C))->_value/*16*/;
  428. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  429. }/*]*/
  430. /*]*/
  431. }
  432.  else if (((((T260*)C))->_value/*16*/)==('\n')) {
  433. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  434. char b1='\134';
  435. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  436. }/*]*/
  437. /*]*/
  438. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  439. char b1='n';
  440. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  441. }/*]*/
  442. /*]*/
  443. }
  444. else {
  445. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  446. char b1='\134';
  447. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  448. }/*]*/
  449. /*]*/
  450. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),r2to_octal(((unsigned char)(((T260*)C))->_value/*16*/)));
  451. /*]*/
  452. }
  453. /*FI*//*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  454. char b1='\47';
  455. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  456. }/*]*/
  457. /*]*/
  458. }
  459. /*No:CHARACTER_CONSTANT.c_simple*/
  460. T0* r260to_runnable(T260* C,T0* a1){
  461. T0* R=NULL;
  462. /*IF*/if (((((T260*)C))->_current_type/*8*/)==((void*)(NULL))) {
  463. C->_current_type=a1;
  464. R=(T0*)C;
  465. }
  466. else {
  467. R=r260twin(C);
  468. /*[IRF3.3set_current_type*/((((T260*)(((T260*)R))))->_current_type)=(a1);
  469. /*]*/
  470. }
  471. /*FI*/return R;
  472. }
  473. int fBC260result_type=0;
  474. T0*oBC260result_type=NULL;
  475. T0* r260result_type(void){
  476. if (fBC260result_type==0){
  477. T0* R=NULL;
  478. fBC260result_type=1;
  479. {T252*n=malloc(sizeof(*n));
  480. *n=M252;
  481. r252make(n,NULL);
  482. R=(T0*)n;
  483. }
  484. oBC260result_type=R;}
  485. return oBC260result_type;}
  486. /*No:CHARACTER_CONSTANT.is_result*/
  487. T0* r260twin(T260* C){
  488. T0* R=NULL;
  489. R=malloc(sizeof(*C));
  490. *((T260*)R)=*C;
  491. return R;
  492. }
  493. /*No:CHARACTER_CONSTANT.set_current_type*/
  494. int r260is_static(T260* C){
  495. int R=0;
  496. R=1;
  497. C->_static_value_mem=/*(IRF4.6to_integer*/((unsigned char)(((T260*)C))->_value/*16*/)/*)*/;
  498. return R;
  499. }
  500. /*No:CHARACTER_CONSTANT.value*/
  501. /*No:CHARACTER_CONSTANT.can_be_dropped*/
  502. /*No:CHARACTER_CONSTANT.current_type*/
  503. /*No:CHARACTER_CONSTANT.compile_to_c_old*/
  504. /*No:CHARACTER_CONSTANT.static_value_mem*/
  505. /*No:CHARACTER_CONSTANT.is_manifest_string*/
  506. /*No:CHARACTER_CONSTANT.is_void*/
  507. /*No:CHARACTER_CONSTANT.pretty_print_mode*/
  508. /*No:CHARACTER_CONSTANT.is_pre_computable*/
  509. /*No:CHARACTER_CONSTANT.use_current*/
  510. void r260error(T0* a1,T0* a2){
  511. r683add_position(a1);
  512. r683error(((T683*)(oBC364eh)),a2);
  513. }
  514. int r260isa_dca_inline_argument(T260* C){
  515. int R=0;
  516. /*IF*/if (r260is_static(C)) {
  517. R=-(1);
  518. }
  519. /*FI*/return R;
  520. }
  521. /*No:CHARACTER_CONSTANT.afd_check*/
  522. /*No:LOOP_INVARIANT.fz_bad_assertion*/
  523. T0* r213runnable(T0* a1,T0* a2,T0* a3){
  524. T0* R=NULL;
  525. T0* _a=NULL;
  526. int _i=0;
  527. /*IF*/if (!(r608empty(((T608*)a1)))) {
  528. R=r608twin(((T608*)a1));
  529. _i=(((T608*)((T608*)R)))->_upper/*8*/;
  530. while (!((_i)==(0))) {
  531. r604push(((T604*)(oBC364small_eiffel)),a3);
  532. _a=r348to_runnable(((T348*)(r608item(((T608*)R),_i))),a2);
  533. /*IF*/if ((_a)==((void*)(NULL))) {
  534. r213error(r348start_position(((T348*)(r608item(((T608*)R),_i)))),((T0*)ms57_470));
  535. }
  536. else {
  537. /*[IRF3.6put*/{T608* C1=((T608*)R);
  538. T0* b1=_a;
  539. int b2=_i;
  540. ((((T608*)C1))->_storage/*0*/)[(b2)-((((T608*)C1))->_lower/*12*/)]=(b1);
  541. }/*]*/
  542. }
  543. /*FI*/r604pop(((T604*)(oBC364small_eiffel)));
  544. _i=(_i)-(1);
  545. }
  546. }
  547. /*FI*/return R;
  548. }
  549. void r213make(T213* C,T0* a1,T0* a2,T0* a3){
  550. C->_start_position=a1;
  551. C->_header_comment=a2;
  552. C->_list=a3;
  553. }
  554. /*No:LOOP_INVARIANT.nb_errors*/
  555. T0* r213check_assertion_mode(void){
  556. T0* R=NULL;
  557. R=((T0*)ms2_213);
  558. return R;
  559. }
  560. /*No:LOOP_INVARIANT.start_position*/
  561. void r213compile_to_c(T213* C){
  562. int _i=0;
  563. /*IF*/if (((((T213*)C))->_list/*8*/)!=((void*)(NULL))) {
  564. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms1_596));
  565. /*]*/
  566. _i=1;
  567. while (!((_i)>((((T608*)((T608*)((((T213*)C))->_list/*8*/))))->_upper/*8*/))) {
  568. /*[IRF3.3set_check_assertion_mode*/((((T324*)(((T324*)(oBC364cpp)))))->_check_assertion_mode)=(r213check_assertion_mode());
  569. /*]*/
  570. r348compile_to_c(((T348*)(r608item(((T608*)((((T213*)C))->_list/*8*/)),_i))));
  571. _i=(_i)+(1);
  572. }
  573. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms2_596));
  574. /*]*/
  575. }
  576. /*FI*/}
  577. T0* r213to_runnable(T213* C,T0* a1){
  578. T0* R=NULL;
  579. /*IF*/if (((((T213*)C))->_current_type/*12*/)==((void*)(NULL))) {
  580. C->_current_type=a1;
  581. /*IF*/if (((((T213*)C))->_list/*8*/)!=((void*)(NULL))) {
  582. C->_list=r213runnable((((T213*)C))->_list/*8*/,a1,r604top_rf(((T604*)(oBC364small_eiffel))));
  583. }
  584. /*FI*//*IF*/if ((/*(IRF4.9nb_errors*/(((T683*)((T683*)(oBC364eh))))->_nb_errors/*0*//*)*/)==(0)) {
  585. R=(T0*)C;
  586. }
  587. /*FI*/}
  588. else {
  589. R=r213twin(C);
  590. /*[IRF3.3set_current_type*/((((T213*)(((T213*)R))))->_current_type)=(NULL);
  591. /*]*/
  592. R=r213to_runnable(((T213*)R),a1);
  593. }
  594. /*FI*/return R;
  595. }
  596. T0* r213twin(T213* C){
  597. T0* R=NULL;
  598. R=malloc(sizeof(*C));
  599. *((T213*)R)=*C;
  600. return R;
  601. }
  602. /*No:LOOP_INVARIANT.set_current_type*/
  603. /*No:LOOP_INVARIANT.list*/
  604. /*No:LOOP_INVARIANT.current_type*/
  605. /*No:LOOP_INVARIANT.header_comment*/
  606. int r213use_current(T213* C){
  607. int R=0;
  608. int _i=0;
  609. /*IF*/if (((((T213*)C))->_list/*8*/)!=((void*)(NULL))) {
  610. _i=(((T608*)((T608*)((((T213*)C))->_list/*8*/))))->_upper/*8*/;
  611. while (!((R)||((_i)==(0)))) {
  612. R=r348use_current(((T348*)(r608item(((T608*)((((T213*)C))->_list/*8*/)),_i))));
  613. _i=(_i)-(1);
  614. }
  615. }
  616. /*FI*/return R;
  617. }
  618. void r213error(T0* a1,T0* a2){
  619. r683add_position(a1);
  620. r683error(((T683*)(oBC364eh)),a2);
  621. }
  622. void r213afd_check(T213* C){
  623. int _i=0;
  624. /*IF*/if (((((T213*)C))->_list/*8*/)!=((void*)(NULL))) {
  625. _i=(((T608*)((T608*)((((T213*)C))->_list/*8*/))))->_upper/*8*/;
  626. while (!((_i)==(0))) {
  627. r348afd_check(((T348*)(r608item(((T608*)((((T213*)C))->_list/*8*/)),_i))));
  628. _i=(_i)-(1);
  629. }
  630. }
  631. /*FI*/}
  632. int fBC364type_character_ref=0;
  633. T0*oBC364type_character_ref=NULL;
  634. T0* r252type_character_ref(void){
  635. if (fBC364type_character_ref==0){
  636. T0* R=NULL;
  637. T0* _character_ref=NULL;
  638. fBC364type_character_ref=1;
  639. {T451*n=malloc(sizeof(*n));
  640. *n=M451;
  641. r451make(n,((T0*)ms9_473),NULL);
  642. _character_ref=(T0*)n;
  643. }
  644. {T657*n=malloc(sizeof(*n));
  645. *n=M657;
  646. /*[IRF3.3make*/((((T657*)(n)))->_base_class_name)=(_character_ref);
  647. /*]*/
  648. R=(T0*)n;
  649. }
  650. oBC364type_character_ref=R;}
  651. return oBC364type_character_ref;}
  652. /*No:TYPE_CHARACTER.id*/
  653. int r252has_creation(T252* C,T0* a1){
  654. int R=0;
  655. r683add_position(X776start_position(a1));
  656. r252error(/*(IRF4.6start_position*/(((T451*)((T451*)((((T252*)C))->_base_class_name/*4*/))))->_start_position/*4*//*)*/,((T0*)ms1_84));
  657. return R;
  658. }
  659. /*No:TYPE_CHARACTER.is_anchored*/
  660. /*No:TYPE_CHARACTER.us_character_ref*/
  661. /*No:TYPE_CHARACTER.is_array*/
  662. /*No:TYPE_CHARACTER.fz_typedef*/
  663. int r252is_a(T252* C,T0* a1){
  664. int R=0;
  665. /*IF*/if (X291is_character(a1)) {
  666. R=1;
  667. }
  668. else {
  669. R=r605is_subclass_of(((T605*)(r252base_class(C))),X291base_class(a1));
  670. /*IF*/if (R) {
  671. r252used_as_reference();
  672. }
  673. /*FI*/}
  674. /*FI*//*IF*/if (!(R)) {
  675. r683add_type((T0*)C,((T0*)ms71_470));
  676. r683add_type(a1,((T0*)ms67_470));
  677. }
  678. /*FI*/return R;
  679. }
  680. /*No:TYPE_CHARACTER.c_initialize_in*/
  681. /*No:TYPE_CHARACTER.c_type_for_argument_in*/
  682. void r252gc_call_new_in(T0* a1){
  683. r7append(((T7*)a1),((T0*)ms115_470));
  684. r2append_in(3,a1);
  685. r7extend(((T7*)a1),'\50');
  686. r7extend(((T7*)a1),'\51');
  687. }
  688. /*No:TYPE_CHARACTER.run_type*/
  689. /*No:TYPE_CHARACTER.is_pointer*/
  690. /*No:TYPE_CHARACTER.is_dummy_expanded*/
  691. /*No:TYPE_CHARACTER.is_string*/
  692. /*No:TYPE_CHARACTER.space_for_variable*/
  693. /*No:TYPE_CHARACTER.is_like_feature*/
  694. /*No:TYPE_CHARACTER.is_like_current*/
  695. void r252make(T252* C,T0* a1){
  696. {T451*n=malloc(sizeof(*n));
  697. *n=M451;
  698. r451make(n,((T0*)ms8_473),a1);
  699. C->_base_class_name=(T0*)n;
  700. }
  701. }
  702. /*No:TYPE_CHARACTER.nb_errors*/
  703. /*No:TYPE_CHARACTER.us_item*/
  704. void r252load_ref(T0* a1){
  705. T0* _rf=NULL;
  706. T0* _rc=NULL;
  707. T0* _cn=NULL;
  708. {T451*n=malloc(sizeof(*n));
  709. *n=M451;
  710. r451make(n,a1,NULL);
  711. _cn=(T0*)n;
  712. }
  713. _rc=r605run_class(((T605*)(r451base_class(((T451*)_cn)))));
  714. r355set_at_run_time(((T355*)_rc));
  715. _rf=r355get_feature_with(((T355*)_rc),((T0*)ms86_473));
  716. }
  717. int fBC252check_type=0;
  718. void r252check_type(T252* C){
  719. if (fBC252check_type==0){
  720. T0* _rc=NULL;
  721. T0* _bc=NULL;
  722. fBC252check_type=1;
  723. _bc=r252base_class(C);
  724. /*IF*/if ((/*(IRF4.9nb_errors*/(((T683*)((T683*)(oBC364eh))))->_nb_errors/*0*//*)*/)==(0)) {
  725. _rc=r252run_class(C);
  726. }
  727. /*FI*//*IF*/if ((/*(IRF4.9nb_errors*/(((T683*)((T683*)(oBC364eh))))->_nb_errors/*0*//*)*/)==(0)) {
  728. /*IF*/if (!((((T605*)((T605*)_bc)))->_is_expanded/*20*/)) {
  729. r252error(/*(IRF4.6start_position*/(((T451*)((T451*)((((T252*)C))->_base_class_name/*4*/))))->_start_position/*4*//*)*/,((T0*)ms1_252));
  730. }
  731. /*FI*/}
  732. /*FI*/}}
  733. /*No:TYPE_CHARACTER.mapping_cast*/
  734. /*No:TYPE_CHARACTER.start_position*/
  735. /*No:TYPE_CHARACTER.c_type_for_target_in*/
  736. /*No:TYPE_CHARACTER.fz_gc_mark*/
  737. /*No:TYPE_CHARACTER.fz_inako*/
  738. /*No:TYPE_CHARACTER.gc_initialize*/
  739. /*No:TYPE_CHARACTER.fz_00*/
  740. /*No:TYPE_CHARACTER.is_character*/
  741. /*No:TYPE_CHARACTER.is_user_expanded*/
  742. T0* r252written_mark(void){
  743. T0* R=NULL;
  744. R=((T0*)ms8_473);
  745. return R;
  746. }
  747. /*No:TYPE_CHARACTER.is_run_type*/
  748. T0* r252to_runnable(T252* C,T0* a1){
  749. T0* R=NULL;
  750. R=(T0*)C;
  751. r252check_type(C);
  752. return R;
  753. }
  754. void r252c_type_for_external_in(T0* a1){
  755. /*IF*//*AF*//*AE*/
  756. /*[IRF3.6c_type_for_result_in*/{T0* b1=a1;
  757. /*[IRF3.6c_type_for_argument_in*/{T0* c1=b1;
  758. r7append(((T7*)c1),((T0*)ms79_470));
  759. }/*]*/
  760. }/*]*/
  761. /*FI*/}
  762. T0* r252generic_list(T252* C){
  763. T0* R=NULL;
  764. r252fatal_error_generic_list(C);
  765. return R;
  766. }
  767. /*No:TYPE_CHARACTER.is_formal_generic*/
  768. void r252demangling_in(T0* a1){
  769. /*IF*//*AF*//*AE*/
  770. r7extend(((T7*)a1),'E');
  771. /*FI*/r7extend(((T7*)a1),'\40');
  772. r7append(((T7*)a1),r252run_time_mark());
  773. }
  774. /*No:TYPE_CHARACTER.is_real*/
  775. /*No:TYPE_CHARACTER.us_character*/
  776. /*No:TYPE_CHARACTER.is_bit*/
  777. void r252fatal_error_generic_list(T252* C){
  778. r683add_type((T0*)C,((T0*)ms12_291));
  779. r683print_as_fatal_error(((T683*)(oBC364eh)));
  780. }
  781. /*No:TYPE_CHARACTER.fz_new*/
  782. T0* r252smallest_ancestor(T252* C,T0* a1){
  783. T0* R=NULL;
  784. T0* _rto=NULL;
  785. _rto=X291run_type(a1);
  786. /*IF*/if (X291is_character(_rto)) {
  787. R=(T0*)C;
  788. }
  789. else {
  790. R=r657smallest_ancestor(((T657*)(r252type_character_ref())),_rto);
  791. }
  792. /*FI*/return R;
  793. }
  794. /*No:TYPE_CHARACTER.is_boolean*/
  795. /*No:TYPE_CHARACTER.is_double*/
  796. T0* r252run_class(T252* C){
  797. T0* R=NULL;
  798. R=r604run_class((T0*)C);
  799. return R;
  800. }
  801. T0* r252run_time_mark(void){
  802. T0* R=NULL;
  803. R=((T0*)ms8_473);
  804. return R;
  805. }
  806. /*No:TYPE_CHARACTER.c_initialize*/
  807. /*No:TYPE_CHARACTER.cast_to_ref*/
  808. void r252gc_mark_in(T0* a1){
  809. r7append(((T7*)a1),((T0*)ms107_470));
  810. r2append_in(3,a1);
  811. }
  812. int r252is_a_in(T252* C,T0* a1,T0* a2){
  813. int R=0;
  814. T0* _ct=NULL;
  815. T0* _t2=NULL;
  816. T0* _t1=NULL;
  817. /*IF*/if ((r252written_mark())==((void*)(X291written_mark(a1)))) {
  818. R=1;
  819. }
  820. else {
  821. _ct=(((T355*)((T355*)a2)))->_current_type/*0*/;
  822. _t1=r252to_runnable(C,_ct);
  823. _t2=X291to_runnable(a1,_ct);
  824. /*IF*/if ((X291run_time_mark(_t1))==((void*)(X291run_time_mark(_t2)))) {
  825. R=1;
  826. }
  827. else {
  828. R=X291is_a(_t1,_t2);
  829. }
  830. /*FI*/}
  831. /*FI*/return R;
  832. }
  833. T0* r252look_up_for(T252* C,T0* a1,T0* a2){
  834. T0* R=NULL;
  835. R=r605look_up_for(((T605*)(r252base_class(C))),a1,a2);
  836. return R;
  837. }
  838. /*No:TYPE_CHARACTER.c_header_pass1*/
  839. /*No:TYPE_CHARACTER.c_type_for_result_in*/
  840. /*No:TYPE_CHARACTER.expanded_initializer*/
  841. /*No:TYPE_CHARACTER.fz_void*/
  842. /*No:TYPE_CHARACTER.fz_dot*/
  843. /*No:TYPE_CHARACTER.is_generic*/
  844. int fBC252used_as_reference=0;
  845. void r252used_as_reference(void){
  846. if (fBC252used_as_reference==0){
  847. fBC252used_as_reference=1;
  848. r252load_ref(((T0*)ms9_473));
  849. }}
  850. /*No:TYPE_CHARACTER.c_header_pass2*/
  851. /*No:TYPE_CHARACTER.gc_define1*/
  852. /*No:TYPE_CHARACTER.need_c_struct*/
  853. /*No:TYPE_CHARACTER.is_reference*/
  854. /*No:TYPE_CHARACTER.gc_info_in*/
  855. void r252error(T0* a1,T0* a2){
  856. r683add_position(a1);
  857. r683error(((T683*)(oBC364eh)),a2);
  858. }
  859. T0* r252base_class(T252* C){
  860. T0* R=NULL;
  861. T0* _bcn=NULL;
  862. _bcn=(((T252*)C))->_base_class_name/*4*/;
  863. /*IF*/if ((_bcn)!=((void*)(NULL))) {
  864. R=r451base_class(((T451*)_bcn));
  865. }
  866. else {
  867. /*[IRF3.6append*/{T0* b1=((T0*)ms3_291);
  868. r7append(((T7*)(oBC683explanation)),b1);
  869. }/*]*/
  870. r683add_type((T0*)C,((T0*)ms67_470));
  871. r683print_as_fatal_error(((T683*)(oBC364eh)));
  872. }
  873. /*FI*/return R;
  874. }
  875. /*No:TYPE_CHARACTER.call_gc_sweep_in*/
  876. /*No:TYPE_CHARACTER.gc_define2*/
  877. /*No:TYPE_CHARACTER.need_gc_mark_function*/
  878. /*No:TYPE_CHARACTER.fz_char*/
  879. /*No:TYPE_CHARACTER.is_any*/
  880. /*No:TYPE_CHARACTER.to_reference*/
  881. /*No:TYPE_CHARACTER.c_header_pass3*/
  882. /*No:TYPE_CHARACTER.base_class_name*/
  883. /*No:TYPE_CHARACTER.is_expanded*/
  884. /*No:TYPE_CHARACTER.is_basic_eiffel_expanded*/
  885. /*No:TYPE_CHARACTER.is_none*/
  886. /*No:TYPE_CHARACTER.to_expanded*/
  887. /*No:TYPE_CHARACTER.is_integer*/
  888. /*No:TYPE_CHARACTER.c_header_pass4*/
  889. void r633add_into(T633* C,T0* a1){
  890. T0* _a=NULL;
  891. int _i=0;
  892. /*IF*/if (((((T633*)C))->_list/*8*/)!=((void*)(NULL))) {
  893. _i=1;
  894. while (!((_i)>((((T608*)((T608*)((((T633*)C))->_list/*8*/))))->_upper/*8*/))) {
  895. _a=r608item(((T608*)((((T633*)C))->_list/*8*/)),_i);
  896. /*IF*/if (!(r608fast_has(((T608*)a1),_a))) {
  897. r608add_last(((T608*)a1),_a);
  898. }
  899. /*FI*/_i=(_i)+(1);
  900. }
  901. }
  902. /*FI*/}
  903. void r633from_runnable(T633* C,T0* a1){
  904. C->_list=a1;
  905. C->_current_type=(((T348*)((T348*)(r608item(((T608*)((((T633*)C))->_list/*8*/)),1)))))->_current_type/*12*/;
  906. }
  907. void r633make(T633* C,T0* a1,T0* a2,T0* a3){
  908. C->_start_position=a1;
  909. C->_header_comment=a2;
  910. C->_list=a3;
  911. }
  912. T0* r633check_assertion_mode(void){
  913. T0* R=NULL;
  914. R=((T0*)ms75_633);
  915. return R;
  916. }
  917. /*No:E_ENSURE.set_header_comment*/
  918. /*No:E_ENSURE.start_position*/
  919. void r633compile_to_c(T633* C){
  920. int _i=0;
  921. /*IF*/if (((((T633*)C))->_list/*8*/)!=((void*)(NULL))) {
  922. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms1_596));
  923. /*]*/
  924. _i=1;
  925. while (!((_i)>((((T608*)((T608*)((((T633*)C))->_list/*8*/))))->_upper/*8*/))) {
  926. /*[IRF3.3set_check_assertion_mode*/((((T324*)(((T324*)(oBC364cpp)))))->_check_assertion_mode)=(r633check_assertion_mode());
  927. /*]*/
  928. r348compile_to_c(((T348*)(r608item(((T608*)((((T633*)C))->_list/*8*/)),_i))));
  929. _i=(_i)+(1);
  930. }
  931. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms2_596));
  932. /*]*/
  933. }
  934. /*FI*/}
  935. /*No:E_ENSURE.set_ensure_then*/
  936. /*No:E_ENSURE.list*/
  937. /*No:E_ENSURE.current_type*/
  938. /*No:E_ENSURE.is_ensure_then*/
  939. void r633compile_to_c_old(T633* C){
  940. int _i=0;
  941. /*IF*/if (((((T633*)C))->_list/*8*/)!=((void*)(NULL))) {
  942. _i=(((T608*)((T608*)((((T633*)C))->_list/*8*/))))->_lower/*12*/;
  943. while (!((_i)>((((T608*)((T608*)((((T633*)C))->_list/*8*/))))->_upper/*8*/))) {
  944. r348compile_to_c_old(((T348*)(r608item(((T608*)((((T633*)C))->_list/*8*/)),_i))));
  945. _i=(_i)+(1);
  946. }
  947. }
  948. /*FI*/}
  949. /*No:E_ENSURE.header_comment*/
  950. int r633use_current(T633* C){
  951. int R=0;
  952. int _i=0;
  953. /*IF*/if (((((T633*)C))->_list/*8*/)!=((void*)(NULL))) {
  954. _i=(((T608*)((T608*)((((T633*)C))->_list/*8*/))))->_upper/*8*/;
  955. while (!((R)||((_i)==(0)))) {
  956. R=r348use_current(((T348*)(r608item(((T608*)((((T633*)C))->_list/*8*/)),_i))));
  957. _i=(_i)-(1);
  958. }
  959. }
  960. /*FI*/return R;
  961. }
  962. void r633afd_check(T633* C){
  963. int _i=0;
  964. /*IF*/if (((((T633*)C))->_list/*8*/)!=((void*)(NULL))) {
  965. _i=(((T608*)((T608*)((((T633*)C))->_list/*8*/))))->_upper/*8*/;
  966. while (!((_i)==(0))) {
  967. r348afd_check(((T348*)(r608item(((T608*)((((T633*)C))->_list/*8*/)),_i))));
  968. _i=(_i)-(1);
  969. }
  970. }
  971. /*FI*/}
  972. int r283id(T283* C){
  973. int R=0;
  974. R=(((T355*)((T355*)(r283run_class(C)))))->_id/*4*/;
  975. return R;
  976. }
  977. int r283has_creation(T283* C,T0* a1){
  978. int R=0;
  979. /*IF*/if ((C)==((void*)((((T283*)C))->_run_type/*12*/))) {
  980. R=r605has_creation(((T605*)(r283base_class(C))),a1);
  981. }
  982. else {
  983. R=X291has_creation((((T283*)C))->_run_type/*12*/,a1);
  984. }
  985. /*FI*/return R;
  986. }
  987. /*No:TYPE_FORMAL_GENERIC.is_anchored*/
  988. int r283is_array(T283* C){
  989. int R=0;
  990. R=X291is_array((((T283*)C))->_run_type/*12*/);
  991. return R;
  992. }
  993. int r283is_a(T283* C,T0* a1){
  994. int R=0;
  995. R=X291is_a((((T283*)C))->_run_type/*12*/,a1);
  996. return R;
  997. }
  998. void r283c_initialize_in(T283* C,T0* a1){
  999. X291c_initialize_in((((T283*)C))->_run_type/*12*/,a1);
  1000. }
  1001. void r283c_type_for_argument_in(T283* C,T0* a1){
  1002. X291c_type_for_argument_in((((T283*)C))->_run_type/*12*/,a1);
  1003. }
  1004. void r283gc_call_new_in(T283* C,T0* a1){
  1005. r7append(((T7*)a1),((T0*)ms115_470));
  1006. r2append_in(r283id(C),a1);
  1007. r7extend(((T7*)a1),'\50');
  1008. r7extend(((T7*)a1),'\51');
  1009. }
  1010. int r283is_pointer(T283* C){
  1011. int R=0;
  1012. R=X291is_pointer((((T283*)C))->_run_type/*12*/);
  1013. return R;
  1014. }
  1015. /*No:TYPE_FORMAL_GENERIC.run_type*/
  1016. int r283is_dummy_expanded(T283* C){
  1017. int R=0;
  1018. R=X291is_dummy_expanded((((T283*)C))->_run_type/*12*/);
  1019. return R;
  1020. }
  1021. int r283is_string(T283* C){
  1022. int R=0;
  1023. R=X291is_string((((T283*)C))->_run_type/*12*/);
  1024. return R;
  1025. }
  1026. int r283space_for_variable(T283* C){
  1027. int R=0;
  1028. R=X291space_for_variable((((T283*)C))->_run_type/*12*/);
  1029. return R;
  1030. }
  1031. /*No:TYPE_FORMAL_GENERIC.is_like_feature*/
  1032. /*No:TYPE_FORMAL_GENERIC.is_like_current*/
  1033. void r283make(T283* C,T0* a1,int a2){
  1034. C->_rank=a2;
  1035. C->_formal_name=a1;
  1036. }
  1037. /*No:TYPE_FORMAL_GENERIC.formal_name*/
  1038. void r283mapping_cast(T283* C){
  1039. /*[IRF3.3clear*/((((T7*)(((T7*)(oBC291tmp_string)))))->_count)=(0);
  1040. /*]*/
  1041. r7extend(((T7*)(oBC291tmp_string)),'\50');
  1042. r283c_type_for_target_in(C,oBC291tmp_string);
  1043. r7extend(((T7*)(oBC291tmp_string)),'\51');
  1044. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),oBC291tmp_string);
  1045. /*]*/
  1046. }
  1047. /*No:TYPE_FORMAL_GENERIC.start_position*/
  1048. void r283c_type_for_target_in(T283* C,T0* a1){
  1049. X291c_type_for_target_in((((T283*)C))->_run_type/*12*/,a1);
  1050. }
  1051. /*No:TYPE_FORMAL_GENERIC.fz_gc_mark*/
  1052. void r283gc_initialize(T283* C){
  1053. X291gc_initialize((((T283*)C))->_run_type/*12*/);
  1054. }
  1055. int r283is_character(T283* C){
  1056. int R=0;
  1057. R=X291is_character((((T283*)C))->_run_type/*12*/);
  1058. return R;
  1059. }
  1060. int r283is_user_expanded(T283* C){
  1061. int R=0;
  1062. R=X291is_user_expanded((((T283*)C))->_run_type/*12*/);
  1063. return R;
  1064. }
  1065. /*No:TYPE_FORMAL_GENERIC.written_mark*/
  1066. /*No:TYPE_FORMAL_GENERIC.is_run_type*/
  1067. T0* r283to_runnable(T283* C,T0* a1){
  1068. T0* R=NULL;
  1069. T0* _gl=NULL;
  1070. T0* _t=NULL;
  1071. T0* _p=NULL;
  1072. T0* _bc_ct=NULL;
  1073. T0* _bc_written=NULL;
  1074. _bc_written=r627base_class(((T627*)(/*(IRF4.6start_position*/(((T451*)((T451*)((((T283*)C))->_formal_name/*4*/))))->_start_position/*4*//*)*/)));
  1075. _bc_ct=X291base_class(a1);
  1076. /*IF*/if ((_bc_written)==((void*)(_bc_ct))) {
  1077. _gl=X291generic_list(a1);
  1078. /*IF*/if (((_gl)==((void*)(NULL)))||(((((T283*)C))->_rank/*8*/)>((((T701*)((T701*)_gl)))->_upper/*8*/))) {
  1079. r683add_position(X291start_position(a1));
  1080. r683add_position(/*(IRF4.6start_position*/(((T451*)((T451*)((((T283*)C))->_formal_name/*4*/))))->_start_position/*4*//*)*/);
  1081. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms61_470);
  1082. r683fatal_error(((T683*)(oBC364eh)),b1);
  1083. }/*]*/
  1084. }
  1085. else {
  1086. R=r283make_runnable(C,r701item(((T701*)_gl),(((T283*)C))->_rank/*8*/));
  1087. }
  1088. /*FI*/}
  1089. else {
  1090. _p=/*(IRF4.6first_parent_for*/r673first_parent_for(((T673*)((((T605*)((T605*)_bc_ct)))->_parent_list/*40*/)),_bc_written)/*)*/;
  1091. while (!((_p)==((void*)(NULL)))) {
  1092. _t=(((T877*)((T877*)_p)))->_type/*4*/;
  1093. _t=X291run_type(X291to_runnable(_t,a1));
  1094. /*IF*/if ((R)==((void*)(NULL))) {
  1095. R=r283to_runnable(C,_t);
  1096. _p=NULL;
  1097. }
  1098. else {
  1099. _p=/*(IRF4.6next_parent_for*/r673next_parent_for(((T673*)((((T605*)((T605*)_bc_ct)))->_parent_list/*40*/)),_bc_written,_p)/*)*/;
  1100. }
  1101. /*FI*/}
  1102. /*IF*/if ((R)==((void*)(NULL))) {
  1103. r683add_type(a1,((T0*)ms1_283));
  1104. r283warning(/*(IRF4.6start_position*/(((T451*)((T451*)((((T283*)C))->_formal_name/*4*/))))->_start_position/*4*//*)*/,((T0*)ms2_283));
  1105. }
  1106. /*FI*/}
  1107. /*FI*/return R;
  1108. }
  1109. /*No:TYPE_FORMAL_GENERIC.rank*/
  1110. void r283c_type_for_external_in(T283* C,T0* a1){
  1111. /*IF*/if (r283is_reference(C)) {
  1112. r7append(((T7*)a1),((T0*)ms133_470));
  1113. r7extend(((T7*)a1),'\52');
  1114. }
  1115. else {
  1116. r283c_type_for_result_in(C,a1);
  1117. }
  1118. /*FI*/}
  1119. T0* r283generic_list(T283* C){
  1120. T0* R=NULL;
  1121. /*IF*/if (r283is_generic(C)) {
  1122. R=X291generic_list((((T283*)C))->_run_type/*12*/);
  1123. }
  1124. else {
  1125. r283fatal_error_generic_list(C);
  1126. }
  1127. /*FI*/return R;
  1128. }
  1129. /*No:TYPE_FORMAL_GENERIC.is_formal_generic*/
  1130. void r283demangling_in(T283* C,T0* a1){
  1131. /*IF*/if (r283is_reference(C)) {
  1132. r7extend(((T7*)a1),'R');
  1133. }
  1134. else {
  1135. r7extend(((T7*)a1),'E');
  1136. }
  1137. /*FI*/r7extend(((T7*)a1),'\40');
  1138. r7append(((T7*)a1),r283run_time_mark(C));
  1139. }
  1140. int r283is_real(T283* C){
  1141. int R=0;
  1142. R=X291is_real((((T283*)C))->_run_type/*12*/);
  1143. return R;
  1144. }
  1145. T0* r283twin(T283* C){
  1146. T0* R=NULL;
  1147. R=malloc(sizeof(*C));
  1148. *((T283*)R)=*C;
  1149. return R;
  1150. }
  1151. /*No:TYPE_FORMAL_GENERIC.fz_bnga*/
  1152. int r283is_bit(T283* C){
  1153. int R=0;
  1154. R=X291is_bit((((T283*)C))->_run_type/*12*/);
  1155. return R;
  1156. }
  1157. T0* r283formal_arg(T283* C){
  1158. T0* R=NULL;
  1159. R=/*(IRF4.6item*/r681item(((T681*)((((T881*)((T881*)(r283formal_generic_list(C)))))->_list/*4*/)),(((T283*)C))->_rank/*8*/)/*)*/;
  1160. return R;
  1161. }
  1162. void r283fatal_error_generic_list(T283* C){
  1163. r683add_type((T0*)C,((T0*)ms12_291));
  1164. r683print_as_fatal_error(((T683*)(oBC364eh)));
  1165. }
  1166. /*No:TYPE_FORMAL_GENERIC.fz_new*/
  1167. T0* r283smallest_ancestor(T283* C,T0* a1){
  1168. T0* R=NULL;
  1169. R=X291smallest_ancestor((((T283*)C))->_run_type/*12*/,a1);
  1170. return R;
  1171. }
  1172. /*No:TYPE_FORMAL_GENERIC.set_run_type*/
  1173. int r283is_boolean(T283* C){
  1174. int R=0;
  1175. R=X291is_boolean((((T283*)C))->_run_type/*12*/);
  1176. return R;
  1177. }
  1178. int r283is_double(T283* C){
  1179. int R=0;
  1180. R=X291is_double((((T283*)C))->_run_type/*12*/);
  1181. return R;
  1182. }
  1183. T0* r283run_class(T283* C){
  1184. T0* R=NULL;
  1185. R=r604run_class((((T283*)C))->_run_type/*12*/);
  1186. return R;
  1187. }
  1188. T0* r283run_time_mark(T283* C){
  1189. T0* R=NULL;
  1190. R=X291run_time_mark((((T283*)C))->_run_type/*12*/);
  1191. return R;
  1192. }
  1193. void r283c_initialize(T283* C){
  1194. X291c_initialize((((T283*)C))->_run_type/*12*/);
  1195. }
  1196. void r283cast_to_ref(T283* C){
  1197. X291cast_to_ref((((T283*)C))->_run_type/*12*/);
  1198. }
  1199. void r283gc_mark_in(T283* C,T0* a1){
  1200. r7append(((T7*)a1),((T0*)ms107_470));
  1201. r2append_in(r283id(C),a1);
  1202. }
  1203. int r283is_a_in(T283* C,T0* a1,T0* a2){
  1204. int R=0;
  1205. T0* _ct=NULL;
  1206. T0* _t2=NULL;
  1207. T0* _t1=NULL;
  1208. /*IF*/if ((/*(IRF4.6written_mark*/(((T451*)((T451*)((((T283*)C))->_formal_name/*4*/))))->_to_string/*0*//*)*/)==((void*)(X291written_mark(a1)))) {
  1209. R=1;
  1210. }
  1211. else {
  1212. _ct=(((T355*)((T355*)a2)))->_current_type/*0*/;
  1213. _t1=r283to_runnable(C,_ct);
  1214. _t2=X291to_runnable(a1,_ct);
  1215. /*IF*/if ((X291run_time_mark(_t1))==((void*)(X291run_time_mark(_t2)))) {
  1216. R=1;
  1217. }
  1218. else {
  1219. R=X291is_a(_t1,_t2);
  1220. }
  1221. /*FI*/}
  1222. /*FI*/return R;
  1223. }
  1224. T0* r283look_up_for(T283* C,T0* a1,T0* a2){
  1225. T0* R=NULL;
  1226. R=r605look_up_for(((T605*)(r283base_class(C))),a1,a2);
  1227. return R;
  1228. }
  1229. void r283c_header_pass1(T283* C){
  1230. X291c_header_pass1((((T283*)C))->_run_type/*12*/);
  1231. }
  1232. void r283c_type_for_result_in(T283* C,T0* a1){
  1233. X291c_type_for_result_in((((T283*)C))->_run_type/*12*/,a1);
  1234. }
  1235. T0* r283expanded_initializer(T283* C){
  1236. T0* R=NULL;
  1237. R=X291expanded_initializer((((T283*)C))->_run_type/*12*/);
  1238. return R;
  1239. }
  1240. T0* r283constraint(T283* C){
  1241. T0* R=NULL;
  1242. R=(((T59*)((T59*)(r283formal_arg(C)))))->_constraint/*4*/;
  1243. return R;
  1244. }
  1245. /*No:TYPE_FORMAL_GENERIC.fz_void*/
  1246. /*No:TYPE_FORMAL_GENERIC.fz_dot*/
  1247. int r283is_generic(T283* C){
  1248. int R=0;
  1249. R=X291is_generic((((T283*)C))->_run_type/*12*/);
  1250. return R;
  1251. }
  1252. /*No:TYPE_FORMAL_GENERIC.fz_bga*/
  1253. /*No:TYPE_FORMAL_GENERIC.used_as_reference*/
  1254. void r283c_header_pass2(T283* C){
  1255. X291c_header_pass2((((T283*)C))->_run_type/*12*/);
  1256. }
  1257. void r283gc_define1(T283* C){
  1258. X291gc_define1((((T283*)C))->_run_type/*12*/);
  1259. }
  1260. int r283need_c_struct(T283* C){
  1261. int R=0;
  1262. R=X291need_c_struct((((T283*)C))->_run_type/*12*/);
  1263. return R;
  1264. }
  1265. T0* r283formal_generic_list(T283* C){
  1266. T0* R=NULL;
  1267. R=(((T605*)((T605*)(r627base_class(((T627*)(/*(IRF4.6start_position*/(((T451*)((T451*)((((T283*)C))->_formal_name/*4*/))))->_start_position/*4*//*)*/)))))))->_formal_generic_list/*28*/;
  1268. return R;
  1269. }
  1270. int r283is_reference(T283* C){
  1271. int R=0;
  1272. R=X291is_reference((((T283*)C))->_run_type/*12*/);
  1273. return R;
  1274. }
  1275. void r283gc_info_in(T283* C,T0* a1){
  1276. X291gc_info_in((((T283*)C))->_run_type/*12*/,a1);
  1277. }
  1278. void r283error(T0* a1,T0* a2){
  1279. r683add_position(a1);
  1280. r683error(((T683*)(oBC364eh)),a2);
  1281. }
  1282. T0* r283base_class(T283* C){
  1283. T0* R=NULL;
  1284. T0* _bcn=NULL;
  1285. _bcn=r283base_class_name(C);
  1286. /*IF*/if ((_bcn)!=((void*)(NULL))) {
  1287. R=r451base_class(((T451*)_bcn));
  1288. }
  1289. else {
  1290. /*[IRF3.6append*/{T0* b1=((T0*)ms3_291);
  1291. r7append(((T7*)(oBC683explanation)),b1);
  1292. }/*]*/
  1293. r683add_type((T0*)C,((T0*)ms67_470));
  1294. r683print_as_fatal_error(((T683*)(oBC364eh)));
  1295. }
  1296. /*FI*/return R;
  1297. }
  1298. void r283call_gc_sweep_in(T283* C,T0* a1){
  1299. X291call_gc_sweep_in((((T283*)C))->_run_type/*12*/,a1);
  1300. }
  1301. void r283gc_define2(T283* C){
  1302. X291gc_define2((((T283*)C))->_run_type/*12*/);
  1303. }
  1304. int r283need_gc_mark_function(T283* C){
  1305. int R=0;
  1306. R=X291need_gc_mark_function((((T283*)C))->_run_type/*12*/);
  1307. return R;
  1308. }
  1309. /*No:TYPE_FORMAL_GENERIC.fatal_error*/
  1310. int r283is_any(T283* C){
  1311. int R=0;
  1312. R=X291is_any((((T283*)C))->_run_type/*12*/);
  1313. return R;
  1314. }
  1315. void r283to_reference(T283* C){
  1316. X291to_reference((((T283*)C))->_run_type/*12*/);
  1317. }
  1318. void r283c_header_pass3(T283* C){
  1319. X291c_header_pass3((((T283*)C))->_run_type/*12*/);
  1320. }
  1321. T0* r283base_class_name(T283* C){
  1322. T0* R=NULL;
  1323. R=X291base_class_name((((T283*)C))->_run_type/*12*/);
  1324. return R;
  1325. }
  1326.  
  1327.